import java.util.Arrays;

public class TestDemo {



//    class Base {
//        Base() {
//            System.out.print("Base");
//        }
//    }
//    public class Alpha extends Base {
//        public static void main( String[] args ) {
//            new Base();
//            new Alpha();
//            //调用父类无参的构造方法
//
//        }
//    }


//    class Test {
//        public static void hello() {
//            System.out.println("hello");
//        }
//    }
//    public class MyApplication {
//        public static void main(String[] args) {
//            Test test=null;
//            test.hello();
//        }
//    }
    public static boolean isOrder(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            //减一防止arr[i+1]越界
            if(arr[i] > arr[i+1]) {
                return false;
            }
        }
        return true;
    }
    //给一个整型数组，判断其是否有序
    public static void main9(String[] args) {
        int[] arr1 = {1,5,6,9,2,8};
        int[] arr = {1,2,3,4,5};
        System.out.println(isOrder(arr));
    }



    //二维数组
    public static void main7(String[] args) {
        int[][] arr = {{1,2,3},{5,8,9}};
        for (int i = 0; i < arr.length ; i++) {
            for (int j = 0; j < arr[i].length ; j++) {
                System.out.print(arr[i][j]+" ");
            }
            
        }
        System.out.println();
        System.out.println("============");
        //tmp和x都是自己定义的
        for (int[] tmp : arr) {
            for (int x : tmp) {
                System.out.print(x+" ");
            }
        }
        System.out.println();
        //以字符串的方式打印二维数组
        System.out.println(Arrays.deepToString(arr));
    }
    
    
    //给定一个整型数组, 判定数组是否有序（递增）


//    给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
//    你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
//    你可以按任意顺序返回答案。
//    输入：nums = [2,7,11,15], target = 9  输出：[0,1]
//    解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
    public static int[] sum(int[] arr,int key) {
        int[] ret = new int[2];
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = arr.length-1;j > i;j-- ) {
                if(arr[i]+arr[j]==key) {
                    ret[0] = i;
                    ret[1] = j;
                }
            }
        }
        return ret;
    }

public static void main6(String[] args) {
    //// 双指针i和j，i从前向后遍历，j从后向i遍历，若arr[i]+arr[j]=target
    int[] arr = {1,2,3,4,5};
    int target = 6;
    sum(arr,target);

}
    //实现一个方法 copyOf, 对一个整型数组进行拷贝, 得到一个新的数组.
    public static void myCopyOf(int[] arr,int len) {
        int[] copy = new int[len];
        for (int i = 0; i < len; i++) {
            copy[i] = arr[i];
        }
        String ret = Arrays.toString(copy);
        System.out.println(ret);
    }

    public static void main5(String[] args) {
        int[] arr = {1,2,3,4,5};
        myCopyOf(arr, arr.length);
        
    }

    //冒泡排序
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length-1; i++) {
            boolean flag = false;
            for (int j = 0;j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    int tmp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = tmp;
                    flag = true;
                }
          //若是没交换则说明已经有序了，即可提前返回结束
            }if (flag == false) {
                return;
            }
        }
    }

//二分查找
    public static int binarySearch(int[] arr,int key) {
        int left = 0;
        int right = arr.length-1;
        while(left <= right) {
            int mid = (left+right)/2;
            if(arr[mid]==key){
                return mid;
            }else if(arr[mid]>key) {
                right = mid - 1;
            }else {
                left = mid + 1;
            }
        }
        return -1;
    }
    //二分查找有序数组中的某个数
    public static void main4(String[] args) {
        int[] arr1 = {1,2,3,4,5,6,9};
       // int ret = binarySearch(arr,3);
      //  System.out.println("数组的下标是"+ret);
       int[] arr = {1,6,5,2,9,4};
       bubbleSort(arr);
        String ret = Arrays.toString(arr);
        System.out.println(ret);
    }


    //toString的实现
    public static void myToString(int[] arr) {
        String ret ="[";
        System.out.print(ret);
        int i =0;
        for(i=0;i<arr.length-1;i++) {
            System.out.print(arr[i] + ",");
        }
        if(i == arr.length-1) {
            System.out.print(arr[i]);
        }
        ret = "]";
        System.out.println(ret);
    }


    //数组转化为字符串,用方法toString
    public static void main3(String[] args) {
        int[] arr={1,2,3,4,5};
//         //工具Arrays要导包才能用，敲回车,toString方法名是小驼峰
//       String ret = Arrays.toString(arr);
//        System.out.println(ret);
//        //用for each遍历数组
//        for (int x:arr) {
//            //右边是要遍历的数组名，左边是数组中元素的类型，然后打印出来放到变量X中
//            System.out.print(x+" ");
//        }
        myToString(arr);
    }

    //创建一个 int 类型的数组, 元素个数为 100,
    // 并把每个元素依次设置为 1 - 100
    public static void main2(String[] args) {
        int[] arr=new int[100];
        int i = 0;
        for (i=0;i<100;i++) {
            arr[i]=i+1;
            System.out.print(arr[i]+" ");
        }
    }
    public static void transform(int []arr) {
        int i =0;
        for(i=0;i< arr.length;i++) {
            arr[i]=2*arr[i];
            System.out.print(arr[i]+" ");
        }
    }
    //实现一个方法 transform, 以数组为参数, 循环将数组中的每个元素 乘以 2 ,
    // 并设置到对应的数组元素上. 例如 原数组为 {1, 2, 3}, 修改之后为 {2, 4, 6}
    public static void main1(String[] args) {
        int[] array = {1,2,3};
        transform(array);
    }

}
